package com.zhitan.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelId;
import io.netty.channel.ChannelOutboundInvoker;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.AttributeKey;
import io.netty.util.concurrent.GlobalEventExecutor;
import io.netty.util.internal.StringUtil;
import lombok.extern.slf4j.Slf4j;

import javax.validation.constraints.NotNull;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * netty的channel仓储
 */
@Slf4j
public class ChannelRepository {

    /**
     * 频道绑定 key
     */
    private final static AttributeKey<String> clientInfo = AttributeKey.valueOf("clientInfo");

    /**
     * 客户端和频道绑定
     */
    private final static Map<String, ChannelId> CHANNEL_MAP = new ConcurrentHashMap<>();

    /**
     * 存储频道
     */
    private final static ChannelGroup CHANNEL_GROUP = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    /**
     * 重入锁
     */
    private static final Lock LOCK = new ReentrantLock();

    /**
     * 获取单机连接数量
     */
    public static int getLocalConnectCount() {
        return CHANNEL_GROUP.size() + 1;
    }

    /**
     * 绑定频道和客户端id
     *
     * @param ctx      连接频道
     * @param deviceNo 设备号
     */
    public static void bind(@NotNull ChannelHandlerContext ctx, @NotNull String deviceNo) {
        LOCK.lock();
        try {
            // 释放旧的连接
            closeAndClean(deviceNo);
            // 绑定设备号到频道上
            ctx.channel().attr(clientInfo).set(deviceNo);
            // 双向保存客户端id和频道
            CHANNEL_MAP.put(deviceNo, ctx.channel().id());
            // 保存频道
            CHANNEL_GROUP.add(ctx.channel());
            log.info("连接通道数量:{}", CHANNEL_MAP.size());
        } finally {
            LOCK.unlock();
        }
    }

    /**
     * 是否已连接
     *
     * @param deviceNo 设备号
     */
    public static boolean hasConnected(String deviceNo) {
        Channel channel = getChannel(deviceNo);
        if (null == channel) {
            return false;
        }
        return channel.isActive();
    }

    /**
     * 是否已登录
     */
    private static boolean isAuth(@NotNull ChannelHandlerContext ctx) {
        return !StringUtil.isNullOrEmpty(getDeviceNo(ctx));
    }

    /**
     * 获取客户端id
     *
     * @param ctx 连接频道
     */
    private static String getDeviceNo(@NotNull ChannelHandlerContext ctx) {
        return ctx.channel().hasAttr(clientInfo) ? ctx.channel().attr(clientInfo).get() : "";
    }

    /**
     * 获取频道
     *
     * @param deviceNo 设备号
     */
    private static Channel getChannel(@NotNull String deviceNo) {
        if (!CHANNEL_MAP.containsKey(deviceNo)) {
            return null;
        }
        ChannelId channelId = CHANNEL_MAP.get(deviceNo);
        return CHANNEL_GROUP.find(channelId);
    }

    /**
     * 释放连接和资源
     * CLIENT_CHANNEL_MAP 需要释放
     * CHANNEL_GROUP 不需要释放，netty会自动帮我们移除
     *
     * @param deviceNo 设备号
     */
    private static void closeAndClean(@NotNull String deviceNo) {
        // 清除绑定关系
        Optional.of(CHANNEL_MAP.containsKey(deviceNo))
                .filter(Boolean::booleanValue)
                .ifPresent(oldChannel ->
                {
                    CHANNEL_MAP.remove(deviceNo);
                });
        // 若存在旧连接，则关闭旧连接，相同deviceNo不允许重复连接
        Optional.ofNullable(getChannel(deviceNo))
                .ifPresent(ChannelOutboundInvoker::close);
    }

    /**
     * 关闭和清理连接
     *
     * @param ctx 连接频道
     */
    public static void closeAndClean(@NotNull ChannelHandlerContext ctx) {
        closeAndClean(getDeviceNo(ctx));
    }

    /**
     * 给设备发消息
     *
     * @param logKey   日志的key
     * @param deviceNo 设备号
     * @param msg      要发送给客户端的消息
     */
    public static void sendMsgToDevice(String logKey, @NotNull String deviceNo, Object msg) {
        Channel channel = getChannel(deviceNo);
        if (channel == null) {
            log.error("通道【{}】不存在", deviceNo);
            return;
        }
        if (null == msg || msg == "") {
            log.error("服务端响应空的消息");
            return;
        }
        ByteBuf byteBuf = (ByteBuf) msg;
        log.debug("KEY=[{}],给设备返回数据:{}", logKey, ByteBufUtil.hexDump(byteBuf));
        //将客户端的信息直接返回写入ctx 并刷新缓存区
        channel.writeAndFlush(msg);
//        byteBuf.release();
    }
}
